import api from './index'


// 用户组相关API
export const groupAPI = {
    // 分页查询用户组
    getGroups(params) {
        return api.get('/api/group/page', { params })
    },

    // 根据ID查询用户组
    getGroupById(id) {
        return api.get(`/api/group/${id}`)
    },

    // 新增用户组
    createGroup(data) {
        return api.post('/api/group', data)
    },

    // 修改用户组
    updateGroup(data) {
        return api.put('/api/group', data)
    },

    // 删除用户组
    deleteGroup(id) {
        return api.delete(`/api/group/${id}`)
    }
}

// 用户组权限关联API
export const groupPermissionAPI = {
    // 分页查询用户组权限关联
    getGroupPermissions(params) {
        return api.get('/api/group-permission/page', { params })
    },

    // 根据ID查询用户组权限关联
    getGroupPermissionById(id) {
        return api.get(`/api/group-permission/${id}`)
    },

    // 新增用户组权限关联
    createGroupPermission(data) {
        return api.post('/api/group-permission', data)
    },

    // 修改用户组权限关联
    updateGroupPermission(data) {
        return api.put('/api/group-permission', data)
    },

    // 删除用户组权限关联
    deleteGroupPermission(id) {
        return api.delete(`/api/group-permission/${id}`)
    },

    // 批量分配权限给用户组（优化版本：并发发送，但限制并发数）
    async assignPermissionsToGroup(groupId, permissionIds) {
        if (!permissionIds || permissionIds.length === 0) {
            return { success: true, message: '没有权限需要分配' }
        }

        // 分批处理，每批最多10个请求并发
        const batchSize = 10
        const batches = []
        
        for (let i = 0; i < permissionIds.length; i += batchSize) {
            batches.push(permissionIds.slice(i, i + batchSize))
        }

        try {
            let totalAssigned = 0
            // 逐批处理，每批内部并发
            for (const batch of batches) {
                const promises = batch.map(permissionId => 
                    this.createGroupPermission({ groupId, permissionId })
                )
                await Promise.all(promises)
                totalAssigned += batch.length
            }
            
            return { success: true, message: `成功分配 ${totalAssigned} 个权限` }
        } catch (error) {
            console.error('批量分配权限失败:', error)
            throw error
        }
    },

    // 批量删除用户组的所有权限（优化版本）
    async removeAllGroupPermissions(groupId) {
        try {
            // 先获取用户组的所有权限关联记录
            const response = await this.getGroupPermissions({
                pageNum: 1,
                pageSize: 1000,
                groupId: groupId
            })
            
            if (response.success && response.data.records.length > 0) {
                const relationIds = response.data.records.map(item => item.id)
                
                // 分批删除，每批最多10个请求并发
                const batchSize = 10
                const batches = []
                
                for (let i = 0; i < relationIds.length; i += batchSize) {
                    batches.push(relationIds.slice(i, i + batchSize))
                }

                let totalDeleted = 0
                // 逐批处理，每批内部并发
                for (const batch of batches) {
                    const promises = batch.map(id => this.deleteGroupPermission(id))
                    await Promise.all(promises)
                    totalDeleted += batch.length
                }
                
                return { success: true, message: `成功删除 ${totalDeleted} 个权限关联` }
            }
            
            return { success: true, message: '没有权限需要删除' }
        } catch (error) {
            console.error('批量删除权限失败:', error)
            throw error
        }
    },

    // 一次性替换用户组的所有权限（推荐使用）
    async replaceGroupPermissions(groupId, permissionIds) {
        try {
            // 先删除所有旧权限
            await this.removeAllGroupPermissions(groupId)
            
            // 再分配新权限
            if (permissionIds && permissionIds.length > 0) {
                await this.assignPermissionsToGroup(groupId, permissionIds)
            }
            
            return { success: true, message: '权限替换成功' }
        } catch (error) {
            console.error('权限替换失败:', error)
            throw error
        }
    }
}

// 用户组关联API
export const userGroupAPI = {
    // 分页查询用户组关联
    getUserGroups(params) {
        return api.get('/api/user-group/page', { params })
    },

    // 根据ID查询用户组关联
    getUserGroupById(id) {
        return api.get(`/api/user-group/${id}`)
    },

    // 新增用户组关联
    createUserGroup(data) {
        return api.post('/api/user-group', data)
    },

    // 修改用户组关联
    updateUserGroup(data) {
        return api.put('/api/user-group', data)
    },

    // 删除用户组关联
    deleteUserGroup(id) {
        return api.delete(`/api/user-group/${id}`)
    },

    // 将用户添加到组
    addUserToGroup(userId, groupId) {
        return this.createUserGroup({ userId, groupId })
    },

    // 从组中移除用户
    removeUserFromGroup(userId, groupId) {
        // 这里需要先查询关联ID，然后删除
        // 实际实现可能需要后端提供更便捷的接口
        return api.delete(`/api/user-group/user/${userId}/group/${groupId}`)
    }
}